package com.ruoyi.functiontest.controller;

import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.math.BigDecimal;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.functiontest.domain.TollAccessStat;
import com.ruoyi.functiontest.service.ITollAccessStatService;
import com.ruoyi.common.utils.poi.ExcelUtil;

/**
 * 联网收费切入数据实测统计Controller
 * 
 * @author ruoyi
 * @date 2025-09-25
 */
@RestController
@RequestMapping("/functiontest/TollAccessStat")
public class TollAccessStatController extends BaseController
{
    private static final Logger logger = LoggerFactory.getLogger(TollAccessStatController.class);
    
    @Autowired
    private ITollAccessStatService tollAccessStatService;

    /**
     * 查询联网收费切入数据实测统计测试列表
     */
    @PreAuthorize("@ss.hasPermi('functiontest:TollAccessStatTest:list')")
    @GetMapping("/list")
    public AjaxResult list(TollAccessStatTest tollAccessStatTest)
    {
        List<TollAccessStatTest> list = tollAccessStatTestService.selectTollAccessStatTestList(tollAccessStatTest);
        
        // 判断是否有搜索条件，如果有则构建树形结构返回
        boolean hasSearchCondition = tollAccessStatTest.getRoadName() != null && !tollAccessStatTest.getRoadName().isEmpty() ||
                                   tollAccessStatTest.getNodeName() != null && !tollAccessStatTest.getNodeName().isEmpty();
        
        if (hasSearchCondition) {
            // 有搜索条件时，构建树形结构返回，包含匹配节点及其所有子节点
            List<TollAccessStatTest> treeList = buildTree(list);
            return success(treeList);
        } else {
            // 无搜索条件时，返回扁平列表
            return success(list);
        }
    }

    /**
     * 导出联网收费切入数据实测统计测试列表
     */
    @PreAuthorize("@ss.hasPermi('functiontest:TollAccessStatTest:export')")
    @Log(title = "联网收费切入数据实测统计测试", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, TollAccessStatTest tollAccessStatTest)
    {
        List<TollAccessStatTest> list = tollAccessStatTestService.selectTollAccessStatTestList(tollAccessStatTest);
        exportCustomExcel(response, list, "联网收费切入数据实测统计测试数据");
    }

    /**
     * 自定义导出Excel（按层级导出）
     */
    private void exportCustomExcel(HttpServletResponse response, List<TollAccessStatTest> list, String sheetName) {
        try {
            // 构建树形结构
            List<TollAccessStatTest> treeList = buildTree(list);
            logger.info("构建树形结构完成，根节点数量: {}", treeList.size());
            
            // 创建新的导出列表，只包含需要导出的数据
            List<TollAccessStatTest> exportList = new ArrayList<>();
            
            // 遍历一级节点（导出路段名称）
            for (TollAccessStatTest level1 : treeList) {
                logger.debug("处理一级节点: {} (ID: {})", level1.getNodeName(), level1.getId());
                
                // 遍历二级节点（不导出）
                List<?> level2Children = level1.getChildren();
                if (level2Children != null && !level2Children.isEmpty()) {
                    logger.debug("一级节点 {} 包含 {} 个二级节点", level1.getNodeName(), level2Children.size());
                    
                    for (Object obj2 : level2Children) {
                        if (obj2 instanceof TollAccessStatTest) {
                            TollAccessStatTest level2 = (TollAccessStatTest) obj2;
                            logger.debug("处理二级节点: {} (ID: {})", level2.getNodeName(), level2.getId());
                            
                            // 遍历三级节点（开始导出）
                            List<?> level3Children = level2.getChildren();
                            if (level3Children != null && !level3Children.isEmpty()) {
                                logger.debug("二级节点 {} 包含 {} 个三级节点", level2.getNodeName(), level3Children.size());
                                
                                // 遍历所有三级节点
                                for (Object obj3 : level3Children) {
                                    if (obj3 instanceof TollAccessStatTest) {
                                        TollAccessStatTest level3 = (TollAccessStatTest) obj3;
                                        logger.debug("处理三级节点: {} (ID: {})", level3.getNodeName(), level3.getId());
                                        
                                        // 获取四级节点列表
                                        List<?> level4Children = level3.getChildren();
                                        
                                        // 处理四级节点
                                        if (level4Children != null && !level4Children.isEmpty()) {
                                            logger.debug("三级节点 {} 包含 {} 个四级节点", level3.getNodeName(), level4Children.size());
                                            
                                            // 遍历所有四级节点
                                            for (Object obj4 : level4Children) {
                                                if (obj4 instanceof TollAccessStatTest) {
                                                    TollAccessStatTest level4 = (TollAccessStatTest) obj4;
                                                    logger.debug("处理四级节点: {} (ID: {})", level4.getNodeName(), level4.getId());
                                                    
                                                    // 创建导出对象，使用一级的路段名称，三级的节点名称和平均距离，四级的行车方向和单向距离
                                                    TollAccessStatTest exportItem = new TollAccessStatTest();
                                                    exportItem.setRoadName(level1.getRoadName());  // 路段名称用一级的
                                                    exportItem.setNodeName(level3.getNodeName());  // 节点名称用三级的（每个四级节点都包含）
                                                    exportItem.setAvgDistance(level3.getAvgDistance());  // 平均距离用三级的（每个四级节点都包含）
                                                    exportItem.setDirection(level4.getDirection());  // 行车方向用四级的
                                                    exportItem.setDistance(level4.getDistance());  // 单向距离用四级的
                                                    exportItem.setTableName(level2.getNodeName());  // 表名用二级的
                                                    exportList.add(exportItem);
                                                    logger.debug("添加导出项: 路段={}, 节点={}, 平均距离={}, 方向={}, 距离={}, 表名={}", 
                                                        level1.getRoadName(), exportItem.getNodeName(), exportItem.getAvgDistance(), 
                                                        level4.getDirection(), level4.getDistance(), level2.getNodeName());
                                                }
                                            }
                                        } else {
                                            // 如果没有四级节点，仍然导出三级节点数据，但行车方向和单向距离为空
                                            logger.debug("三级节点 {} 没有四级子节点，导出三级节点数据，行车方向和单向距离为空");
                                            TollAccessStatTest exportItem = new TollAccessStatTest();
                                            exportItem.setRoadName(level1.getRoadName());  // 路段名称用一级的
                                            exportItem.setNodeName(level3.getNodeName());  // 节点名称用三级的
                                            exportItem.setAvgDistance(level3.getAvgDistance());  // 平均距离用三级的
                                            exportItem.setDirection("-");  // 行车方向使用占位符
                                            exportItem.setDistance(new BigDecimal("0"));  // 单向距离使用0作为占位符
                                            exportItem.setTableName(level2.getNodeName());  // 表名用二级的
                                            exportList.add(exportItem);
                                            logger.debug("添加导出项: 路段={}, 节点={}, 平均距离={}, 方向={}, 距离={}, 表名={}", 
                                                level1.getRoadName(), level3.getNodeName(), level3.getAvgDistance(), 
                                                "-", 0, level2.getNodeName());
                                        }
                                    }
                                }
                            } else {
                                // 如果没有三级节点，跳过导出
                                logger.debug("二级节点 {} 没有三级子节点，跳过导出", level2.getNodeName());
                            }
                        }
                    }
                } else {
                    // 如果没有二级节点，跳过导出
                    logger.debug("一级节点 {} 没有二级子节点，跳过导出", level1.getNodeName());
                }
            }
            
            logger.info("导出数据准备完成，共 {} 条记录", exportList.size());
            
            // 使用系统自带的Excel导出（支持单元格合并）
            ExcelUtil<TollAccessStatTest> util = new ExcelUtil<TollAccessStatTest>(TollAccessStatTest.class);
            util.exportExcel(response, exportList, sheetName);
        } catch (Exception e) {
            logger.error("导出Excel失败", e);
        }
    }

    /**
     * 获取联网收费切入数据实测统计测试详细信息
     */
    @PreAuthorize("@ss.hasPermi('functiontest:TollAccessStatTest:query')")
    @GetMapping(value = "/{id}")
    public AjaxResult getInfo(@PathVariable("id") Long id)
    {
        return success(tollAccessStatTestService.selectTollAccessStatTestById(id));
    }

    /**
     * 构建树形结构
     */
    private List<TollAccessStatTest> buildTree(List<TollAccessStatTest> list) {
        // 构建父子关系映射
        Map<Long, TollAccessStatTest> nodeMap = new HashMap<>();
        List<TollAccessStatTest> rootNodes = new ArrayList<>();
        
        // 先将所有节点放入map中
        for (TollAccessStatTest node : list) {
            nodeMap.put(node.getId(), node);
        }
        
        // 构建父子关系
        for (TollAccessStatTest node : list) {
            Long parentId = node.getParentId();
            if (parentId != null && parentId != 0) {
                TollAccessStatTest parent = nodeMap.get(parentId);
                if (parent != null) {
                    if (parent.getChildren() == null) {
                        parent.setChildren(new ArrayList<TollAccessStatTest>());
                    }
                    @SuppressWarnings("unchecked")
                    List<TollAccessStatTest> children = (List<TollAccessStatTest>) parent.getChildren();
                    children.add(node);
                }
            } else {
                rootNodes.add(node);
            }
        }
        
        return rootNodes;
    }

    /**
     * 新增联网收费切入数据实测统计测试
     */
    @PreAuthorize("@ss.hasPermi('functiontest:TollAccessStatTest:add')")
    @Log(title = "联网收费切入数据实测统计测试", businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody TollAccessStatTest tollAccessStatTest)
    {
        int result = tollAccessStatTestService.insertTollAccessStatTest(tollAccessStatTest);
        if (result > 0) {
            // 插入成功后返回包含ID的完整对象
            return success(tollAccessStatTest);
        } else {
            return error("新增失败");
        }
    }

    /**
     * 修改联网收费切入数据实测统计测试
     */
    @PreAuthorize("@ss.hasPermi('functiontest:TollAccessStatTest:edit')")
    @Log(title = "联网收费切入数据实测统计测试", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody TollAccessStatTest tollAccessStatTest)
    {
        return toAjax(tollAccessStatTestService.updateTollAccessStatTest(tollAccessStatTest));
    }

    /**
     * 删除联网收费切入数据实测统计测试
     */
    @PreAuthorize("@ss.hasPermi('functiontest:tollAccessStatTest:remove')")
    @Log(title = "联网收费切入数据实测统计测试", businessType = BusinessType.DELETE)
	@DeleteMapping("/{ids}")
    public AjaxResult remove(@PathVariable Long[] ids)
    {
        for (Long id : ids) {
            if (tollAccessStatTestService.hasChildById(id)) {
                return AjaxResult.error("节点存在子节点，请先删除子节点后再删除父节点");
            }
        }
        return toAjax(tollAccessStatTestService.deleteTollAccessStatTestByIds(ids));
    }
}
